// 确保扩展程序已准备好接收消息
console.log('Content script loaded for:', window.location.href);

// 使用立即执行函数将所有内容封装在私有作用域中
(function() {
    // 声明变量跟踪初始化状态
    let initialized = false;
    let debug = false; // 调试模式开关
    
    // 安全的日志函数
    function log(message, data) {
        if (debug || message.includes('error') || message.includes('失败') || message.includes('出错')) {
            console.log(message, data ? data : '');
        }
    }
    
    // 安全的错误日志函数
    function errorLog(message, error) {
        console.error(message, error ? error : '');
    }
    
    // 跟踪页面加载状态以避免重复初始化
    if (document.readyState === "loading") {
        document.addEventListener("DOMContentLoaded", initializeContentScript);
    } else {
        // 延迟初始化以避免与页面脚本冲突
        setTimeout(initializeContentScript, 500);
    }
    
    // 初始化内容脚本
    function initializeContentScript() {
        // 防止多次初始化
        if (initialized) return;
        initialized = true;
        
        try {
            // 通知background.js内容脚本已加载
            notifyBackgroundScriptLoaded();
            
            // 设置消息监听器
            setupMessageListeners();
            
            // 设置表单监听
            setupFormListeners();
            
            log('内容脚本已初始化:', window.location.href);
        } catch (error) {
            errorLog('初始化内容脚本时出错:', error);
        }
    }
    
    // 通知后台脚本内容脚本已加载
    function notifyBackgroundScriptLoaded() {
        try {
            chrome.runtime.sendMessage({ 
                type: 'CONTENT_SCRIPT_LOADED',
                url: window.location.href
            }, response => {
                if (chrome.runtime.lastError) {
                    errorLog('通知后台脚本失败:', chrome.runtime.lastError.message);
                }
            });
        } catch (error) {
            errorLog('发送加载通知时出错:', error);
        }
    }
    
    // 设置消息监听器
    function setupMessageListeners() {
        try {
            chrome.runtime.onMessage.addListener((request, sender, sendResponse) => {
                try {
                    log('内容脚本收到消息:', request.type);
                    
                    // 响应PING消息以确认内容脚本已加载
                    if (request.type === 'PING') {
                        sendResponse({ status: 'alive', url: window.location.href });
                        return true;
                    }
                    
                    if (request.type === 'AUTO_FILL') {
                        handleAutoFill(request, sendResponse);
                        return true; // 保持消息通道开放
                    }
                    
                    // 对于其他未知消息类型，确保返回响应
                    sendResponse({ received: true, messageType: request.type });
                    return true; // 保持消息通道开放
                } catch (error) {
                    errorLog('处理消息时出错:', serializeError(error));
                    sendResponse({ success: false, error: serializeError(error) });
                    return true;
                }
            });
        } catch (error) {
            errorLog('设置消息监听器时出错:', serializeError(error));
        }
    }
    
    // 处理自动填充
    function handleAutoFill(request, sendResponse) {
        try {
            const { username, password } = request.data;
            log('尝试自动填充用户名和密码');
            
            // 查找输入框
            let usernameField = null;
            let passwordField = null;
            
            try {
                // 首先尝试使用更简单、更兼容的方法找到密码字段
                const simpleResult = findSimpleLoginFields();
                usernameField = simpleResult.usernameField;
                passwordField = simpleResult.passwordField;
                
                // 如果简单方法失败，尝试更高级的方法
                if (!usernameField || !passwordField) {
                    const advancedResult = findAdvancedLoginFields();
                    if (!usernameField) usernameField = advancedResult.usernameField;
                    if (!passwordField) passwordField = advancedResult.passwordField;
                }
            } catch (findError) {
                errorLog('查找输入框时出错:', serializeError(findError));
            }
            
            try {
                // 填充用户名
                if (usernameField) {
                    safelyFillValue(usernameField, username);
                    log('用户名已填充');
                } else {
                    log('未找到用户名字段');
                }
            } catch (userError) {
                errorLog('填充用户名时出错:', serializeError(userError));
            }
            
            try {
                // 填充密码
                if (passwordField) {
                    safelyFillValue(passwordField, password);
                    log('密码已填充');
                } else {
                    log('未找到密码字段');
                }
            } catch (passError) {
                errorLog('填充密码时出错:', serializeError(passError));
            }
            
            // 确保返回响应
            sendResponse({ 
                success: true, 
                usernameField: !!usernameField,
                passwordField: !!passwordField
            });
        } catch (error) {
            errorLog('自动填充过程中出错:', serializeError(error));
            sendResponse({ 
                success: false, 
                error: serializeError(error)
            });
        }
    }
    
    // 简单地查找登录字段 - 更保守，更兼容的方法
    function findSimpleLoginFields() {
        let usernameField = null;
        let passwordField = null;
        
        try {
            // 查找密码输入框 - 最简单直接的方式
            const passwordInputs = document.querySelectorAll('input[type="password"]');
            if (passwordInputs.length > 0) {
                passwordField = passwordInputs[0];
                
                // 如果找到密码字段，尝试在附近找用户名字段
                // 通常是密码字段之前的文本或邮件输入框
                const possibleUserFields = document.querySelectorAll('input[type="text"], input[type="email"]');
                for (const field of possibleUserFields) {
                    if (field.offsetParent !== null && !field.disabled && !field.readOnly) {
                        usernameField = field;
                        break;
                    }
                }
            }
        } catch (error) {
            errorLog('简单查找登录字段时出错:', serializeError(error));
        }
        
        return { usernameField, passwordField };
    }
    
    // 更高级的查找登录字段方法
    function findAdvancedLoginFields() {
        let usernameField = null;
        let passwordField = null;
        
        try {
            // 尝试在活跃表单中查找
            const forms = document.forms;
            let activeForm = null;
            
            // 找到可能是登录表单的表单
            for (const form of forms) {
                const passwordInputs = form.querySelectorAll('input[type="password"]');
                if (passwordInputs.length > 0) {
                    activeForm = form;
                    break;
                }
            }
            
            if (activeForm) {
                // 在表单中找密码字段
                const passwordInputs = activeForm.querySelectorAll('input[type="password"]');
                if (passwordInputs.length > 0) {
                    passwordField = passwordInputs[0];
                }
                
                // 在表单中找用户名字段
                if (passwordField) {
                    const textInputs = activeForm.querySelectorAll('input[type="text"], input[type="email"]');
                    if (textInputs.length > 0) {
                        for (const input of textInputs) {
                            if (input.offsetParent !== null && !input.disabled && !input.readOnly) {
                                usernameField = input;
                                break;
                            }
                        }
                    }
                }
            }
            
            // 如果还没找到密码字段，尝试查找页面上任何可能的密码字段
            if (!passwordField) {
                // 这里添加额外的识别方法
                const possiblePasswordInputs = document.querySelectorAll(
                    'input[type="password"], input[name*="pass"], input[id*="pass"], input[name*="pwd"], input[id*="pwd"]'
                );
                
                for (const input of possiblePasswordInputs) {
                    if (input.offsetParent !== null && !input.disabled && !input.readOnly) {
                        passwordField = input;
                        break;
                    }
                }
            }
        } catch (error) {
            errorLog('高级查找登录字段时出错:', serializeError(error));
        }
        
        return { usernameField, passwordField };
    }
    
    // 安全地填充值
    function safelyFillValue(field, value) {
        try {
            // 最简单的方法
            field.value = value;
            
            // 尝试触发输入事件
            try {
                field.dispatchEvent(new Event('input', { bubbles: true }));
                field.dispatchEvent(new Event('change', { bubbles: true }));
            } catch (eventError) {
                // 忽略事件错误
            }
        } catch (error) {
            errorLog('设置输入值时出错:', serializeError(error));
        }
    }
    
    // 设置表单监听器
    function setupFormListeners() {
        try {
            // 使用简单的事件监听方式
            document.addEventListener('submit', event => {
                try {
                    const form = event.target;
                    
                    // 确保是表单元素
                    if (form.tagName.toLowerCase() !== 'form') return;
                    
                    const inputFields = form.querySelectorAll('input');
                    let username = '';
                    let password = '';
                    
                    // 查找用户名和密码
                    for (const input of inputFields) {
                        if (input.type === 'password' && input.value) {
                            password = input.value;
                        } else if ((input.type === 'text' || input.type === 'email') && input.value) {
                            username = input.value;
                        }
                    }
                    
                    if (username && password) {
                        // 发送保存请求到后台脚本
                        saveCredentials(username, password);
                    }
                } catch (error) {
                    errorLog('处理表单提交时出错:', serializeError(error));
                }
            }, true);
        } catch (error) {
            errorLog('设置表单监听器时出错:', serializeError(error));
        }
    }
    
    // 保存凭据到后台
    function saveCredentials(username, password) {
        try {
            log('正在发送凭据到后台');
            chrome.runtime.sendMessage({
                type: 'SAVE_CREDENTIALS',
                data: {
                    url: window.location.hostname,
                    username,
                    password
                }
            }, response => {
                if (chrome.runtime.lastError) {
                    errorLog('发送凭据时出错:', chrome.runtime.lastError.message);
                }
            });
        } catch (error) {
            errorLog('保存凭据时出错:', serializeError(error));
        }
    }
    
    // 将错误对象转换为可序列化的对象
    function serializeError(error) {
        if (!error) return 'Unknown error';
        if (typeof error === 'string') return error;
        
        const serialized = {
            message: error.message || 'No message',
            name: error.name || 'Error'
        };
        
        if (error.stack) {
            serialized.stack = error.stack;
        }
        
        // 添加额外的非标准属性
        for (const key in error) {
            if (typeof error[key] !== 'function' && !serialized[key]) {
                try {
                    serialized[key] = String(error[key]);
                } catch (e) {
                    serialized[key] = 'Cannot serialize';
                }
            }
        }
        
        return serialized;
    }
})(); // 立即执行函数结束 